泛型

/**
 * 截取数组
 * @param {*} arr 给定一段数组
 * @param {*} n 截取数组前 n 项
 */
// <T> 给定一种类型，对函数进行类型约束
function take<T> (arr: T[], n: number): T[] {  // <T = number> 设置默认类型
    if (n >= arr.length) return arr;
    const newArr: T[] = [];
    for (let i = 0; i < n; i ++) {
        newArr.push(arr[i])
    }
    return newArr;
}

take<number>([1, 2, 3, 4, 5], 3);

泛型-类型别名

type callback<T> = (n: T, i: number) => boolean;

function fillter<T> (arr: T[], callback: callback<T>): T[] {
    const newArr: T[] = [];
    arr.forEach((n, i) => {
        if (callback(n, i)) newArr.push(n);
    })
    return newArr;
}

fillter([1, 2, 3, 4, 5], n => n % 2 !== 0);

泛型-接口

interface callback<T> {(n: T, i: number): boolean}

function fillter<T> (arr: T[], callback: callback<T>): T[] {
    const newArr: T[] = [];
    arr.forEach((n, i) => {
        if (callback(n, i)) newArr.push(n);
    })
    return newArr;
}

fillter([1, 2, 3, 4, 5], n => n % 2 !== 0);

泛型-类

class Car<T> {
    fn (num: T) {
        return num
    }
}

let car = new Car();
console.log(car.fn(123));

泛型约束

interface A {name: string}

function toUpperCase<T extends A> (obj: T) {
    obj.name = obj.name.split(' ')
                       .map(s => s[0].toUpperCase() + s.substr(1))
                       .join(' ');
    return obj;
}

const obj = {
    name: 'hello word',
    age: 18,
}

const newObj = toUpperCase(obj);
console.log(newObj.name);  //--> Hello Word

多泛型

// 混合两个数组
function mixinArray<T, K> (arr1: T[], arr2: K[]): (T | K)[] {
    if (arr1.length != arr2.length) {
        throw new Error('两个数组不等长');
    }
    let result: (T | K)[] = [];
    for (let i = 0; i < arr1.length; i++) {
        result.push(arr1[i]);
        result.push(arr2[i]);
    }
    return result;
}

let arr = mixinArray([1, 2, 3], ['a', 'b', 'c']);
console.log(arr);  //--> [1, 'a', 2, 'b', 3, 'c']